home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / alpha.arc / SESSION.C < prev    next >
C/C++ Source or Header  |  1988-03-29  |  8KB  |  357 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "netuser.h"
  7. #include "timer.h"
  8. #include "tcp.h"
  9. #include "ax25.h"
  10. #include "lapb.h"
  11. #include "ftp.h"
  12. #include "telnet.h"
  13. #include "session.h"
  14. #include "cmdparse.h"
  15.  
  16. struct session *sessions;
  17. struct session *current;
  18. char notval[] = "Not a valid control block\n";
  19. char badsess[] = "Invalid session\n";
  20.  
  21. /* Convert a character string containing a decimal session index number 
  22.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  23.  * If the index is out of range or unused, return NULLSESSION.
  24.  */
  25. static struct session *
  26. sessptr(cp)
  27. char *cp;
  28. {
  29.     register struct session *s;
  30.     unsigned int i;
  31.  
  32.     if(cp == NULLCHAR){
  33.         s = current;
  34.     } else {
  35.         if((i = atoi(cp)) >= nsessions)
  36.             return NULLSESSION;
  37.         s = &sessions[i];
  38.     }
  39.     if(s == NULLSESSION || s->type == FREE)
  40.         return NULLSESSION;
  41.  
  42.     return s;
  43. }
  44.  
  45. /* Select and display sessions */
  46. dosession(argc,argv)
  47. int argc;
  48. char *argv[];
  49. {
  50.     struct session *s;
  51.     extern char *tcpstates[];
  52.     char *psocket();
  53.     extern char *ax25states[];
  54.     char *tcp_port();
  55.  
  56.     if(argc > 1){
  57.         if((current = sessptr(argv[1])) != NULLSESSION)
  58.             go();
  59.         return 0;
  60.     }
  61.     printf(" #       &CB Type   Rcv-Q  State        Remote socket\n");
  62.     for(s=sessions; s < &sessions[nsessions];s++){
  63.         switch(s->type){
  64.         case TELNET:
  65.             printf("%c%-3d%8lx Telnet  %4d  %-13s%-s:%s",
  66.              (current == s)? '*':' ',
  67.              (int)(s - sessions),
  68.              (long)s->cb.telnet->tcb,
  69.              s->cb.telnet->tcb->rcvcnt,
  70.              tcpstates[s->cb.telnet->tcb->state],
  71.              s->name,
  72.              tcp_port(s->cb.telnet->tcb->conn.remote.port));
  73.             break;
  74.         case FTP:
  75.             printf("%c%-3d%8lx FTP     %4d  %-13s%-s:%s",
  76.              (current == s)? '*':' ',
  77.              (int)(s - sessions),
  78.              (long)s->cb.ftp->control,
  79.              s->cb.ftp->control->rcvcnt,
  80.              tcpstates[s->cb.ftp->control->state],
  81.              s->name,
  82.              tcp_port(s->cb.ftp->control->conn.remote.port));
  83.             break;
  84. #ifdef    AX25
  85.         case AX25TNC:
  86.             printf("%c%-3d%8lx AX25    %4d  %-13s%-s",
  87.              (current == s)? '*':' ',
  88.              (int)(s - sessions),
  89.              (long)s->cb.ax25_cb,
  90.             len_mbuf(s->cb.ax25_cb->rxq),
  91.              ax25states[s->cb.ax25_cb->state],
  92.              s->name);
  93.             break;
  94. #endif
  95.         default:
  96.             continue;
  97.         }
  98.         if(s->rfile != NULLCHAR || s->ufile != NULLCHAR)
  99.             printf("\t");
  100.         if(s->rfile != NULLCHAR)
  101.             printf("Record: %s ",s->rfile);
  102.         if(s->ufile != NULLCHAR)
  103.             printf("Upload: %s",s->ufile);
  104.         printf("\n");
  105.     }
  106.     return 0;
  107. }
  108. /* Enter conversational mode with current session */
  109. int
  110. go()
  111. {
  112.     void rcv_char(),ftpccr(),ax_rx();
  113.  
  114.     if(current == NULLSESSION || current->type == FREE)
  115.         return 0;
  116.     mode = CONV_MODE;
  117.     switch(current->type){
  118.     case TELNET:
  119.         if(current->cb.telnet->remote[TN_ECHO])
  120.             raw();    /* Re-establish raw mode if it was set */
  121.         rcv_char(current->cb.telnet->tcb,0); /* Get any pending input */
  122.         break;
  123.     case FTP:
  124.         ftpccr(current->cb.ftp->control,0);
  125.         break;
  126. #ifdef    AX25
  127.     case AX25TNC:
  128.         ax_rx(current->cb.ax25_cb,0);
  129.         break;
  130. #endif
  131.     }
  132.     return 0;
  133. }
  134. doclose(argc,argv)
  135. int argc;
  136. char *argv[];
  137. {
  138.     struct session *s;
  139.  
  140.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  141.         printf(badsess);
  142.         return -1;
  143.     }
  144.     switch(s->type){
  145.     case TELNET:
  146.         close_tcp(s->cb.telnet->tcb);
  147.         break;
  148.     case FTP:
  149.         close_tcp(s->cb.ftp->control);
  150.         break;
  151. #ifdef    AX25
  152.     case AX25TNC:
  153.         disc_ax25(s->cb.ax25_cb);
  154.         break;
  155. #endif
  156.     }
  157.     return 0;
  158. }
  159. doreset(argc,argv)
  160. int argc;
  161. char *argv[];
  162. {
  163.     long htol();
  164.     struct session *s;
  165.  
  166.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  167.         printf(badsess);
  168.         return -1;
  169.     }
  170.     switch(s->type){
  171.     case TELNET:
  172.         reset_tcp(s->cb.telnet->tcb);
  173.         break;
  174.     case FTP:
  175.         if(s->cb.ftp->data != NULLTCB){
  176.             reset_tcp(s->cb.ftp->data);
  177.             s->cb.ftp->data = NULLTCB;
  178.         }
  179.         reset_tcp(s->cb.ftp->control);
  180.         break;
  181. #ifdef    AX25
  182.     case AX25TNC:
  183.         reset_ax25(s->cb.ax25_cb);
  184.         break;
  185. #endif
  186.     }
  187.     return 0;
  188. }
  189. int
  190. dokick(argc,argv)
  191. int argc;
  192. char *argv[];
  193. {
  194.     long htol();
  195.     void tcp_timeout();
  196.     struct session *s;
  197.  
  198.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  199.         printf(badsess);
  200.         return -1;
  201.     }
  202.     switch(s->type){
  203.     case TELNET:
  204.         if(kick_tcp(s->cb.telnet->tcb) == -1){
  205.             printf(notval);
  206.             return 1;
  207.         }
  208.         break;
  209.     case FTP:
  210.         if(kick_tcp(s->cb.ftp->control) == -1){
  211.  
  212.             printf(notval);
  213.             return 1;
  214.         }
  215.         if(s->cb.ftp->data != NULLTCB)
  216.             kick_tcp(s->cb.ftp->data);
  217.         break;
  218. #ifdef    AX25
  219.     case AX25TNC:
  220.         if(kick_ax25(s->cb.ax25_cb) == -1){
  221.             printf(notval);
  222.             return 1;
  223.         }
  224.         return 1;
  225. #endif
  226.     }
  227.     return 0;
  228. }
  229. struct session *
  230. newsession()
  231. {
  232.     register int i;
  233.  
  234.     for(i=0;i<nsessions;i++)
  235.         if(sessions[i].type == FREE)
  236.             return &sessions[i];
  237.     return NULLSESSION;
  238. }
  239. freesession(s)
  240. struct session *s;
  241. {
  242.     if(s == NULLSESSION)
  243.         return;
  244.     if(s->record != NULLFILE){
  245.         fclose(s->record);
  246.         s->record = NULLFILE;
  247.     }
  248.     if(s->rfile != NULLCHAR){
  249.         free(s->rfile);
  250.         s->rfile = NULLCHAR;
  251.     }
  252.     if(s->upload != NULLFILE){
  253.         fclose(s->upload);
  254.         s->upload = NULLFILE;
  255.     }
  256.     if(s->ufile != NULLCHAR){
  257.         free(s->ufile);
  258.         s->ufile = NULLCHAR;
  259.     }
  260.     if(s->name != NULLCHAR){
  261.         free(s->name);
  262.         s->name = NULLCHAR;
  263.     }
  264.     s->type = FREE;
  265. }
  266. /* Control session recording */
  267. dorecord(argc,argv)
  268. int argc;
  269. char *argv[];
  270. {
  271.     if(current == NULLSESSION){
  272.         printf("No current session\n");
  273.         return 1;
  274.     }
  275.     if(argc > 1){
  276.         if(current->rfile != NULLCHAR){
  277.             fclose(current->record);
  278.             free(current->rfile);
  279.             current->record = NULLFILE;
  280.             current->rfile = NULLCHAR;
  281.         }
  282.         /* Open new record file, unless file name is "off", which means
  283.          * disable recording
  284.          */
  285.         if(strcmp(argv[1],"off") != 0
  286.          && (current->record = fopen(argv[1],"a")) != NULLFILE){
  287.             current->rfile = malloc((unsigned)strlen(argv[1])+1);
  288.             strcpy(current->rfile,argv[1]);
  289.         }
  290.     }
  291.     if(current->rfile != NULLCHAR)
  292.         printf("Recording into %s\n",current->rfile);
  293.     else
  294.         printf("Recording off\n");
  295.     return 0;
  296. }
  297. /* Control file transmission */
  298. doupload(argc,argv)
  299. int argc;
  300. char *argv[];
  301. {
  302.     struct tcb *tcb;
  303.     struct ax25_cb *axp;
  304.  
  305.     if(current == NULLSESSION){
  306.         printf("No current session\n");
  307.         return 1;
  308.     }
  309.     if(argc > 1){
  310.         switch(current->type){
  311.         case TELNET:
  312.             tcb = current->cb.telnet->tcb;
  313.             break;
  314. #ifdef    AX25
  315.         case AX25TNC:
  316.             axp = current->cb.ax25_cb;
  317.             break;
  318. #endif
  319.         case FTP:
  320.             printf("Uploading on FTP control channel not supported\n");
  321.             return 1;
  322.         }
  323.         if(strcmp(argv[1],"stop") == 0 && current->upload != NULLFILE){
  324.             /* Abort upload */
  325.             fclose(current->upload);
  326.             current->upload = NULLFILE;
  327.             if(current->ufile != NULLCHAR){
  328.                 free(current->ufile);
  329.                 current->ufile = NULLCHAR;
  330.             }
  331.         }
  332.         /* Open upload file */
  333.         if((current->upload = fopen(argv[1],"r")) == NULLFILE){
  334.             printf("Can't read %s\n",argv[1]);
  335.             return 1;
  336.         }
  337.         current->ufile = malloc((unsigned)strlen(argv[1])+1);
  338.         strcpy(current->ufile,argv[1]);
  339.         /* All set, kick transmit upcall to get things rolling */
  340.         switch(current->type){
  341. #ifdef    AX25
  342.         case AX25TNC:
  343.             (*axp->t_upcall)(axp,axp->paclen * axp->maxframe);
  344.             break;
  345. #endif
  346.         case TELNET:
  347.             (*tcb->t_upcall)(tcb,tcb->snd.wnd - tcb->sndcnt);
  348.             break;
  349.         }
  350.     }
  351.     if(current->ufile != NULLCHAR)
  352.         printf("Uploading %s\n",current->ufile);
  353.     else
  354.         printf("Uploading off\n");
  355.     return 0;
  356. }
  357.